#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
#include <stdio.h>
#include <ctime>

#define NUM 5

using namespace std;


void *threadRun(void* args)
{
    const char*name = static_cast<const char *>(args);

    int cnt = 5;
    while(cnt)
    {
        cout << name << " is running: " << cnt-- << " obtain self id: " << pthread_self() << endl;
        sleep(1);
    }

    //pthread_cancel(pthread_self());

    pthread_exit((void*)11); 

}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRun, (void*)"thread 1");
    // sleep(3);

    //取消线程
    pthread_cancel(tid);// PTHREAD_CANCELED; #define PTHREAD_CANCELED ((void *) -1)
    //pthread_cancel(pthread_self());

    void *ret = nullptr;
    pthread_join(tid, &ret);
    cout << " new thread exit : " << (int64_t)ret << " quit thread: " << tid << endl;
    return 0;
}







// class Thread
// {
// public:
//     Thread(const int id, const string& name, const long int& time)
//         :_id(id)
//         ,_name(name)
//         ,_creatTime(time)
//     {}

// public:
//     int _id;
//     string _name;
//     long int _creatTime;
// };


// //线程终止：
// //1.线程代码执行完return
// //2.exit()，exit()是直接退出进程，一旦某个线程调用了exit函数，那么所有的线程就都会退出
// //3.pthread_exit()

// void *thread_run(void *args)
// {
//     //char* str = (char*)args;
//     Thread* th = static_cast<Thread*>(args);

//     while (1)
//     {
//         cout << "thread name :" << th->_name << " id :" << th->_id << " creatTime :" << th->_creatTime << endl;
//         //cout << "new thread running, tname : " << str << endl;
//         //exit(-1);
//         sleep(1);
//         break;
//     }

//     pthread_exit(th);
    
//     //return nullptr;
//     //return (void*)1;
//     //return (void*)"quit";
//     //pthread_exit((void*)1);
// }

// int main()
// {
//     pthread_t tids[NUM];

//     for(int i = 0; i < NUM; ++i)
//     {
//         //在堆上开辟空间之后就不会出现以下的问题了， 因为每个线程都有独立的堆空间
//         //char* tname = new char[64];
//         char tname[64];//传数组的时候，每次循环都会将原来的数组中的内容进行覆盖，所以看到结果并不是我们预料的那样，当然这也跟调度器什么时候调度该线程有关
//         snprintf(tname, 64, "tname-%d", i+1);
//         Thread* th = new Thread(tids[i], tname, time(nullptr));

//         pthread_create(&tids[i], nullptr, thread_run, th);
//         sleep(1);
//     }


//     void* retval = nullptr;
//     //线程也是需要等待的，如果一个线程退出了，主线程并没有进行等待，那么该线程就会面临像僵尸进程一样的问题。
//     for(int i = 0; i < NUM; ++i)
//     {
//        pthread_join(tids[i], &retval);//阻塞式被等待,如果等待的线程没有退出，主线程就会一直等待该线程退出,不做其他事。
//        //cout << tids[i] << "退出码: " << (int)retval << endl; 

//        Thread* th = static_cast<Thread*>(retval);
//        cout << th->_id << " " << th->_name << " quit" << endl;
//     }
//     cout << "#######thread quit...#######" << endl;


//     //sleep(3);
//     //return 0;//如果主线程退出了，相当于进程退出，那么进程的所有资源被释放，所有的线程也就全部被释放了。
//     //哪个线程先跑跟调度器有关，和父进程和子进程一样。
//     // while (1)
//     // {
//     //     cout << "main thread running, new thread id : " << endl;
//     //     sleep(1);
//     // }

//     return 0;
// }
